18#include "config/aom_config.h"
23#elif !defined(STDOUT_FILENO)
24#define STDOUT_FILENO 1
30#include "aom_ports/aom_timer.h"
31#include "aom_ports/mem_ops.h"
32#include "common/args.h"
33#include "common/ivfdec.h"
34#include "common/md5_utils.h"
35#include "common/obudec.h"
36#include "common/tools_common.h"
39#include "common/webmdec.h"
42#include "common/rawenc.h"
43#include "common/y4menc.h"
46#include "third_party/libyuv/include/libyuv/scale.h"
49static const char *exec_name;
51struct AvxDecInputContext {
52 struct AvxInputContext *aom_input_ctx;
53 struct ObuDecInputContext *obu_ctx;
54 struct WebmInputContext *webm_ctx;
57static const arg_def_t help =
58 ARG_DEF(NULL,
"help", 0,
"Show usage options and exit");
59static const arg_def_t looparg =
60 ARG_DEF(NULL,
"loops", 1,
"Number of times to decode the file");
61static const arg_def_t codecarg = ARG_DEF(NULL,
"codec", 1,
"Codec to use");
62static const arg_def_t use_yv12 =
63 ARG_DEF(NULL,
"yv12", 0,
"Output raw YV12 frames");
64static const arg_def_t use_i420 =
65 ARG_DEF(NULL,
"i420", 0,
"Output raw I420 frames");
66static const arg_def_t flipuvarg =
67 ARG_DEF(NULL,
"flipuv", 0,
"Flip the chroma planes in the output");
68static const arg_def_t rawvideo =
69 ARG_DEF(NULL,
"rawvideo", 0,
"Output raw YUV frames");
70static const arg_def_t noblitarg =
71 ARG_DEF(NULL,
"noblit", 0,
"Don't process the decoded frames");
72static const arg_def_t progressarg =
73 ARG_DEF(NULL,
"progress", 0,
"Show progress after each frame decodes");
74static const arg_def_t limitarg =
75 ARG_DEF(NULL,
"limit", 1,
"Stop decoding after n frames");
76static const arg_def_t skiparg =
77 ARG_DEF(NULL,
"skip", 1,
"Skip the first n input frames");
78static const arg_def_t summaryarg =
79 ARG_DEF(NULL,
"summary", 0,
"Show timing summary");
80static const arg_def_t outputfile =
81 ARG_DEF(
"o",
"output", 1,
"Output file name pattern (see below)");
82static const arg_def_t threadsarg =
83 ARG_DEF(
"t",
"threads", 1,
"Max threads to use");
84static const arg_def_t rowmtarg =
85 ARG_DEF(NULL,
"row-mt", 1,
"Enable row based multi-threading, default: 0");
86static const arg_def_t verbosearg =
87 ARG_DEF(
"v",
"verbose", 0,
"Show version string");
88static const arg_def_t scalearg =
89 ARG_DEF(
"S",
"scale", 0,
"Scale output frames uniformly");
90static const arg_def_t continuearg =
91 ARG_DEF(
"k",
"keep-going", 0,
"(debug) Continue decoding after error");
92static const arg_def_t fb_arg =
93 ARG_DEF(NULL,
"frame-buffers", 1,
"Number of frame buffers to use");
94static const arg_def_t md5arg =
95 ARG_DEF(NULL,
"md5", 0,
"Compute the MD5 sum of the decoded frame");
96static const arg_def_t framestatsarg =
97 ARG_DEF(NULL,
"framestats", 1,
"Output per-frame stats (.csv format)");
98static const arg_def_t outbitdeptharg =
99 ARG_DEF(NULL,
"output-bit-depth", 1,
"Output bit-depth for decoded frames");
100static const arg_def_t isannexb =
101 ARG_DEF(NULL,
"annexb", 0,
"Bitstream is in Annex-B format");
102static const arg_def_t oppointarg = ARG_DEF(
103 NULL,
"oppoint", 1,
"Select an operating point of a scalable bitstream");
104static const arg_def_t outallarg = ARG_DEF(
105 NULL,
"all-layers", 0,
"Output all decoded frames of a scalable bitstream");
106static const arg_def_t skipfilmgrain =
107 ARG_DEF(NULL,
"skip-film-grain", 0,
"Skip film grain application");
109static const arg_def_t *all_args[] = {
110 &help, &codecarg, &use_yv12, &use_i420,
111 &flipuvarg, &rawvideo, &noblitarg, &progressarg,
112 &limitarg, &skiparg, &summaryarg, &outputfile,
113 &threadsarg, &rowmtarg, &verbosearg, &scalearg,
114 &fb_arg, &md5arg, &framestatsarg, &continuearg,
115 &outbitdeptharg, &isannexb, &oppointarg, &outallarg,
122 FilterModeEnum mode) {
123 if (src->
fmt != dst->
fmt) {
125 "%s failed to scale output frame because format changed from %s to "
127 exec_name, image_format_to_string(dst->
fmt),
128 image_format_to_string(src->
fmt));
150 fprintf(stderr,
"%s cannot scale output frame of format %s\n", exec_name,
151 image_format_to_string(src->
fmt));
156static void show_help(FILE *fout,
int shorthelp) {
157 fprintf(fout,
"Usage: %s <options> filename\n\n", exec_name);
160 fprintf(fout,
"Use --help to see the full list of options.\n");
164 fprintf(fout,
"Options:\n");
165 arg_show_usage(fout, all_args);
167 "\nOutput File Patterns:\n\n"
168 " The -o argument specifies the name of the file(s) to "
169 "write to. If the\n argument does not include any escape "
170 "characters, the output will be\n written to a single file. "
171 "Otherwise, the filename will be calculated by\n expanding "
172 "the following escape characters:\n");
174 "\n\t%%w - Frame width"
175 "\n\t%%h - Frame height"
176 "\n\t%%<n> - Frame number, zero padded to <n> places (1..9)"
177 "\n\n Pattern arguments are only supported in conjunction "
178 "with the --yv12 and\n --i420 options. If the -o option is "
179 "not specified, the output will be\n directed to stdout.\n");
180 fprintf(fout,
"\nIncluded decoders:\n\n");
182 for (
int i = 0; i < get_aom_decoder_count(); ++i) {
184 fprintf(fout,
" %-6s - %s\n", get_short_name_by_aom_decoder(decoder),
189void usage_exit(
void) {
190 show_help(stderr, 1);
194static int raw_read_frame(
struct AvxInputContext *input_ctx, uint8_t **buffer,
195 size_t *bytes_read,
size_t *buffer_size) {
196 unsigned char raw_hdr[RAW_FRAME_HDR_SZ];
197 size_t frame_size = 0;
199 if (read_from_input(input_ctx, RAW_FRAME_HDR_SZ, raw_hdr) !=
201 if (!input_eof(input_ctx))
202 aom_tools_warn(
"Failed to read RAW frame size\n");
204 const size_t kCorruptFrameThreshold = 256 * 1024 * 1024;
205 const size_t kFrameTooSmallThreshold = 256 * 1024;
206 frame_size = mem_get_le32(raw_hdr);
208 if (frame_size > kCorruptFrameThreshold) {
209 aom_tools_warn(
"Read invalid frame size (%u)\n",
210 (
unsigned int)frame_size);
214 if (frame_size < kFrameTooSmallThreshold) {
216 "Warning: Read invalid frame size (%u) - not a raw file?\n",
217 (
unsigned int)frame_size);
220 if (frame_size > *buffer_size) {
221 uint8_t *new_buf = realloc(*buffer, 2 * frame_size);
224 *buffer_size = 2 * frame_size;
226 aom_tools_warn(
"Failed to allocate compressed data buffer\n");
232 if (!input_eof(input_ctx)) {
233 if (read_from_input(input_ctx, frame_size, *buffer) != frame_size) {
234 aom_tools_warn(
"Failed to read full frame\n");
237 *bytes_read = frame_size;
244static int read_frame(
struct AvxDecInputContext *input, uint8_t **buf,
245 size_t *bytes_in_buffer,
size_t *buffer_size) {
246 switch (input->aom_input_ctx->file_type) {
249 return webm_read_frame(input->webm_ctx, buf, bytes_in_buffer,
253 return raw_read_frame(input->aom_input_ctx, buf, bytes_in_buffer,
256 return ivf_read_frame(input->aom_input_ctx, buf, bytes_in_buffer,
259 return obudec_read_temporal_unit(input->obu_ctx, buf, bytes_in_buffer,
265static int file_is_raw(
struct AvxInputContext *input) {
269 memset(&si, 0,
sizeof(si));
271 if (buffer_input(input, 32, buf,
true) == 32) {
274 if (mem_get_le32(buf) < 256 * 1024 * 1024) {
275 for (i = 0; i < get_aom_decoder_count(); ++i) {
279 input->fourcc = get_fourcc_by_aom_decoder(decoder);
281 input->height = si.
h;
282 input->framerate.numerator = 30;
283 input->framerate.denominator = 1;
290 rewind_detect(input);
294static void show_progress(
int frame_in,
int frame_out, uint64_t dx_time) {
296 "%d decoded frames/%d showed frames in %" PRId64
" us (%.2f fps)\r",
297 frame_in, frame_out, dx_time,
298 (
double)frame_out * 1000000.0 / (
double)dx_time);
301struct ExternalFrameBuffer {
307struct ExternalFrameBufferList {
308 int num_external_frame_buffers;
309 struct ExternalFrameBuffer *ext_fb;
316static int get_av1_frame_buffer(
void *cb_priv,
size_t min_size,
319 struct ExternalFrameBufferList *
const ext_fb_list =
320 (
struct ExternalFrameBufferList *)cb_priv;
321 if (ext_fb_list == NULL)
return -1;
324 for (i = 0; i < ext_fb_list->num_external_frame_buffers; ++i) {
325 if (!ext_fb_list->ext_fb[i].in_use)
break;
328 if (i == ext_fb_list->num_external_frame_buffers)
return -1;
330 if (ext_fb_list->ext_fb[i].size < min_size) {
331 free(ext_fb_list->ext_fb[i].data);
332 ext_fb_list->ext_fb[i].data = (uint8_t *)calloc(min_size,
sizeof(uint8_t));
333 if (!ext_fb_list->ext_fb[i].data)
return -1;
335 ext_fb_list->ext_fb[i].size = min_size;
338 fb->
data = ext_fb_list->ext_fb[i].data;
339 fb->
size = ext_fb_list->ext_fb[i].size;
340 ext_fb_list->ext_fb[i].in_use = 1;
343 fb->
priv = &ext_fb_list->ext_fb[i];
350static int release_av1_frame_buffer(
void *cb_priv,
352 struct ExternalFrameBuffer *
const ext_fb =
353 (
struct ExternalFrameBuffer *)fb->
priv;
359static void generate_filename(
const char *pattern,
char *out,
size_t q_len,
360 unsigned int d_w,
unsigned int d_h,
361 unsigned int frame_in) {
362 const char *p = pattern;
366 char *next_pat = strchr(p,
'%');
374 case 'w': snprintf(q, q_len - 1,
"%d", d_w);
break;
375 case 'h': snprintf(q, q_len - 1,
"%d", d_h);
break;
376 case '1': snprintf(q, q_len - 1,
"%d", frame_in);
break;
377 case '2': snprintf(q, q_len - 1,
"%02d", frame_in);
break;
378 case '3': snprintf(q, q_len - 1,
"%03d", frame_in);
break;
379 case '4': snprintf(q, q_len - 1,
"%04d", frame_in);
break;
380 case '5': snprintf(q, q_len - 1,
"%05d", frame_in);
break;
381 case '6': snprintf(q, q_len - 1,
"%06d", frame_in);
break;
382 case '7': snprintf(q, q_len - 1,
"%07d", frame_in);
break;
383 case '8': snprintf(q, q_len - 1,
"%08d", frame_in);
break;
384 case '9': snprintf(q, q_len - 1,
"%09d", frame_in);
break;
385 default: die(
"Unrecognized pattern %%%c\n", p[1]);
389 if (pat_len >= q_len - 1) die(
"Output filename too long.\n");
398 copy_len = strlen(p);
400 copy_len = next_pat - p;
402 if (copy_len >= q_len - 1) die(
"Output filename too long.\n");
404 memcpy(q, p, copy_len);
413static int is_single_file(
const char *outfile_pattern) {
414 const char *p = outfile_pattern;
418 if (p && p[1] >=
'1' && p[1] <=
'9')
426static void print_md5(
unsigned char digest[16],
const char *filename) {
429 for (i = 0; i < 16; ++i) printf(
"%02x", digest[i]);
430 printf(
" %s\n", filename);
433static FILE *open_outfile(
const char *name) {
434 if (strcmp(
"-", name) == 0) {
435 set_binary_mode(stdout);
438 FILE *file = fopen(name,
"wb");
439 if (!file) fatal(
"Failed to open output file '%s'", name);
444static int main_loop(
int argc,
const char **argv_) {
448 int ret = EXIT_FAILURE;
450 size_t bytes_in_buffer = 0, buffer_size = 0;
452 int frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
453 int do_md5 = 0, progress = 0;
454 int stop_after = 0, summary = 0, quiet = 1;
457 uint64_t dx_time = 0;
459 char **argv, **argi, **argj;
467 unsigned int fixed_output_bit_depth = 0;
468 unsigned int is_annexb = 0;
469 int frames_corrupted = 0;
472 int operating_point = 0;
473 int output_all_layers = 0;
474 int skip_film_grain = 0;
475 int enable_row_mt = 0;
478 int frame_avail, got_data, flush_decoder = 0;
479 int num_external_frame_buffers = 0;
480 struct ExternalFrameBufferList ext_fb_list = { 0, NULL };
482 const char *outfile_pattern = NULL;
483 char outfile_name[PATH_MAX] = { 0 };
484 FILE *outfile = NULL;
486 FILE *framestats_file = NULL;
489 unsigned char md5_digest[16];
491 struct AvxDecInputContext input = { NULL, NULL, NULL };
492 struct AvxInputContext aom_input_ctx;
493 memset(&aom_input_ctx, 0,
sizeof(aom_input_ctx));
495 struct WebmInputContext webm_ctx;
496 memset(&webm_ctx, 0,
sizeof(webm_ctx));
497 input.webm_ctx = &webm_ctx;
499 struct ObuDecInputContext obu_ctx = { NULL, NULL, 0, 0, 0 };
502 obu_ctx.avx_ctx = &aom_input_ctx;
503 input.obu_ctx = &obu_ctx;
504 input.aom_input_ctx = &aom_input_ctx;
507 exec_name = argv_[0];
508 argv = argv_dup(argc - 1, argv_ + 1);
510 fprintf(stderr,
"Error allocating argument list\n");
515 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
516 memset(&arg, 0,
sizeof(arg));
519 if (arg_match(&arg, &help, argi)) {
520 show_help(stdout, 0);
522 }
else if (arg_match(&arg, &codecarg, argi)) {
523 interface = get_aom_decoder_by_short_name(arg.val);
525 die(
"Error: Unrecognized argument (%s) to --codec\n", arg.val);
526 }
else if (arg_match(&arg, &looparg, argi)) {
528 }
else if (arg_match(&arg, &outputfile, argi)) {
529 outfile_pattern = arg.val;
530 }
else if (arg_match(&arg, &use_yv12, argi)) {
536 }
else if (arg_match(&arg, &use_i420, argi)) {
542 }
else if (arg_match(&arg, &rawvideo, argi)) {
547 }
else if (arg_match(&arg, &flipuvarg, argi)) {
549 }
else if (arg_match(&arg, &noblitarg, argi)) {
551 }
else if (arg_match(&arg, &progressarg, argi)) {
553 }
else if (arg_match(&arg, &limitarg, argi)) {
554 stop_after = arg_parse_uint(&arg);
555 }
else if (arg_match(&arg, &skiparg, argi)) {
556 arg_skip = arg_parse_uint(&arg);
557 }
else if (arg_match(&arg, &md5arg, argi)) {
559 }
else if (arg_match(&arg, &framestatsarg, argi)) {
560 framestats_file = fopen(arg.val,
"w");
561 if (!framestats_file) {
562 die(
"Error: Could not open --framestats file (%s) for writing.\n",
565 }
else if (arg_match(&arg, &summaryarg, argi)) {
567 }
else if (arg_match(&arg, &threadsarg, argi)) {
568 cfg.
threads = arg_parse_uint(&arg);
569#if !CONFIG_MULTITHREAD
571 die(
"Error: --threads=%d is not supported when CONFIG_MULTITHREAD = "
576 }
else if (arg_match(&arg, &rowmtarg, argi)) {
577 enable_row_mt = arg_parse_uint(&arg);
578 }
else if (arg_match(&arg, &verbosearg, argi)) {
580 }
else if (arg_match(&arg, &scalearg, argi)) {
582 }
else if (arg_match(&arg, &fb_arg, argi)) {
583 num_external_frame_buffers = arg_parse_uint(&arg);
584 }
else if (arg_match(&arg, &continuearg, argi)) {
586 }
else if (arg_match(&arg, &outbitdeptharg, argi)) {
587 fixed_output_bit_depth = arg_parse_uint(&arg);
588 }
else if (arg_match(&arg, &isannexb, argi)) {
590 input.obu_ctx->is_annexb = 1;
591 }
else if (arg_match(&arg, &oppointarg, argi)) {
592 operating_point = arg_parse_int(&arg);
593 }
else if (arg_match(&arg, &outallarg, argi)) {
594 output_all_layers = 1;
595 }
else if (arg_match(&arg, &skipfilmgrain, argi)) {
603 for (argi = argv; *argi; argi++)
604 if (argi[0][0] ==
'-' && strlen(argi[0]) > 1)
605 die(
"Error: Unrecognized option %s\n", *argi);
612 fprintf(stderr,
"No input file specified!\n");
616 const bool using_file = strcmp(fn,
"-") != 0;
618 infile = using_file ? fopen(fn,
"rb") : set_binary_mode(stdin);
621 fatal(
"Failed to open input file '%s'", using_file ? fn :
"stdin");
625 if (!outfile_pattern && isatty(STDOUT_FILENO) && !do_md5 && !noblit) {
627 "Not dumping raw video to your terminal. Use '-o -' to "
633 input.aom_input_ctx->filename = fn;
634 input.aom_input_ctx->file = infile;
642 }
else if (using_file && file_is_webm(input.webm_ctx, input.aom_input_ctx)) {
643 input.aom_input_ctx->file_type = FILE_TYPE_WEBM;
645 }
else if (file_is_ivf(input.aom_input_ctx)) {
646 input.aom_input_ctx->file_type = FILE_TYPE_IVF;
648 }
else if (file_is_obu(&obu_ctx)) {
649 input.aom_input_ctx->file_type = FILE_TYPE_OBU;
650 }
else if (file_is_raw(input.aom_input_ctx)) {
651 input.aom_input_ctx->file_type = FILE_TYPE_RAW;
653 fprintf(stderr,
"Unrecognized input file type.\n");
656 fprintf(stderr,
"aomdec does not support piped WebM input.\n");
659 fprintf(stderr,
"aomdec was built without WebM container support.\n");
665 outfile_pattern = outfile_pattern ? outfile_pattern :
"-";
666 single_file = is_single_file(outfile_pattern);
668 if (!noblit && single_file) {
669 generate_filename(outfile_pattern, outfile_name, PATH_MAX,
670 aom_input_ctx.width, aom_input_ctx.height, 0);
674 outfile = open_outfile(outfile_name);
677 if (use_y4m && !noblit) {
680 "YUV4MPEG2 not supported with output patterns,"
681 " try --i420 or --yv12 or --rawvideo.\n");
686 if (aom_input_ctx.file_type == FILE_TYPE_WEBM) {
687 if (webm_guess_framerate(input.webm_ctx, input.aom_input_ctx)) {
689 "Failed to guess framerate -- error parsing "
698 get_aom_decoder_by_fourcc(aom_input_ctx.fourcc);
700 if (is_ivf && !fourcc_interface)
701 fatal(
"Unsupported fourcc: %x\n", aom_input_ctx.fourcc);
703 if (interface && fourcc_interface && interface != fourcc_interface)
704 aom_tools_warn(
"Header indicates codec: %s\n",
707 interface = fourcc_interface;
709 if (!interface)
interface = get_aom_decoder_by_index(0);
713 fprintf(stderr,
"Failed to initialize decoder: %s\n",
718 if (!quiet) fprintf(stderr,
"%s\n", decoder.
name);
721 fprintf(stderr,
"Failed to set is_annexb: %s\n",
aom_codec_error(&decoder));
727 fprintf(stderr,
"Failed to set operating_point: %s\n",
733 output_all_layers)) {
734 fprintf(stderr,
"Failed to set output_all_layers: %s\n",
741 fprintf(stderr,
"Failed to set skip_film_grain: %s\n",
747 fprintf(stderr,
"Failed to set row multithreading mode: %s\n",
752 if (arg_skip) fprintf(stderr,
"Skipping first %d frames.\n", arg_skip);
754 if (read_frame(&input, &buf, &bytes_in_buffer, &buffer_size))
break;
758 if (num_external_frame_buffers > 0) {
759 ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
760 ext_fb_list.ext_fb = (
struct ExternalFrameBuffer *)calloc(
761 num_external_frame_buffers,
sizeof(*ext_fb_list.ext_fb));
762 if (!ext_fb_list.ext_fb) {
763 fprintf(stderr,
"Failed to allocate ExternalFrameBuffer\n");
767 release_av1_frame_buffer,
769 fprintf(stderr,
"Failed to configure external frame buffers: %s\n",
778 if (framestats_file) fprintf(framestats_file,
"bytes,qp\r\n");
781 while (frame_avail || got_data) {
784 struct aom_usec_timer timer;
788 if (!stop_after || frame_in < stop_after) {
789 if (!read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
793 aom_usec_timer_start(&timer);
797 aom_tools_warn(
"Failed to decode frame %d: %s", frame_in,
800 if (detail) aom_tools_warn(
"Additional information: %s", detail);
801 if (!keep_going)
goto fail;
804 if (framestats_file) {
808 aom_tools_warn(
"Failed AOMD_GET_LAST_QUANTIZER: %s",
810 if (!keep_going)
goto fail;
812 fprintf(framestats_file,
"%d,%d\r\n", (
int)bytes_in_buffer, qp);
815 aom_usec_timer_mark(&timer);
816 dx_time += aom_usec_timer_elapsed(&timer);
824 aom_usec_timer_start(&timer);
829 aom_tools_warn(
"Failed to flush decoder: %s",
834 aom_usec_timer_mark(&timer);
835 dx_time += aom_usec_timer_elapsed(&timer);
846 aom_tools_warn(
"Failed AOM_GET_FRAME_CORRUPTED: %s",
848 if (!keep_going)
goto fail;
850 frames_corrupted += corrupted;
852 if (progress) show_progress(frame_in, frame_out, dx_time);
857 const int *planes = flipuv ? PLANES_YVU : PLANES_YUV;
860 if (frame_out == 1) {
866 int render_width = aom_input_ctx.width;
867 int render_height = aom_input_ctx.height;
868 if (!render_width || !render_height) {
873 render_width = img->
d_w;
874 render_height = img->
d_h;
876 render_width = render_size[0];
877 render_height = render_size[1];
883 fprintf(stderr,
"Failed to allocate scaled image (%d x %d)\n",
884 render_width, render_height);
889 scaled_img->
csp = img->
csp;
892 if (img->
d_w != scaled_img->
d_w || img->
d_h != scaled_img->
d_h) {
894 if (libyuv_scale(img, scaled_img, kFilterBox) != 0)
goto fail;
899 "Failed to scale output frame: %s.\n"
900 "libyuv is required for scaling but is currently disabled.\n"
901 "Be sure to specify -DCONFIG_LIBYUV=1 when running cmake.\n",
908 unsigned int output_bit_depth;
909 if (!fixed_output_bit_depth && single_file) {
912 output_bit_depth = fixed_output_bit_depth;
915 if (output_bit_depth != 0) {
916 if (!aom_shift_img(output_bit_depth, &img, &img_shifted)) {
917 fprintf(stderr,
"Error allocating image\n");
922 aom_input_ctx.width = img->
d_w;
923 aom_input_ctx.height = img->
d_h;
925 int num_planes = (opt_raw && img->
monochrome) ? 1 : 3;
928 char y4m_buf[Y4M_BUFFER_SIZE] = { 0 };
930 if (frame_out == 1) {
932 len = y4m_write_file_header(
933 y4m_buf,
sizeof(y4m_buf), aom_input_ctx.width,
934 aom_input_ctx.height, &aom_input_ctx.framerate,
939 "Warning: Y4M lacks a colorspace for colocated "
940 "chroma. Using a placeholder.\n");
943 MD5Update(&md5_ctx, (md5byte *)y4m_buf, (
unsigned int)len);
945 fputs(y4m_buf, outfile);
950 len = y4m_write_frame_header(y4m_buf,
sizeof(y4m_buf));
952 MD5Update(&md5_ctx, (md5byte *)y4m_buf, (
unsigned int)len);
953 y4m_update_image_md5(img, planes, &md5_ctx);
955 fputs(y4m_buf, outfile);
956 y4m_write_image_file(img, planes, outfile);
959 if (frame_out == 1) {
966 "Cannot produce i420 output for bit-stream.\n");
975 "Cannot produce yv12 output for bit-stream.\n");
981 raw_update_image_md5(img, planes, num_planes, &md5_ctx);
983 raw_write_image_file(img, planes, num_planes, outfile);
987 generate_filename(outfile_pattern, outfile_name, PATH_MAX, img->
d_w,
992 y4m_update_image_md5(img, planes, &md5_ctx);
994 raw_update_image_md5(img, planes, num_planes, &md5_ctx);
996 MD5Final(md5_digest, &md5_ctx);
997 print_md5(md5_digest, outfile_name);
999 outfile = open_outfile(outfile_name);
1001 y4m_write_image_file(img, planes, outfile);
1003 raw_write_image_file(img, planes, num_planes, outfile);
1012 if (summary || progress) {
1013 show_progress(frame_in, frame_out, dx_time);
1014 fprintf(stderr,
"\n");
1017 if (frames_corrupted) {
1018 fprintf(stderr,
"WARNING: %d frames corrupted.\n", frames_corrupted);
1026 fprintf(stderr,
"Failed to destroy decoder: %s\n",
1032 if (!noblit && single_file) {
1034 MD5Final(md5_digest, &md5_ctx);
1035 print_md5(md5_digest, outfile_name);
1042 if (input.aom_input_ctx->file_type == FILE_TYPE_WEBM)
1043 webm_free(input.webm_ctx);
1045 if (input.aom_input_ctx->file_type == FILE_TYPE_OBU)
1046 obudec_free(input.obu_ctx);
1048 if (input.aom_input_ctx->file_type != FILE_TYPE_WEBM) free(buf);
1053 for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
1054 free(ext_fb_list.ext_fb[i].data);
1056 free(ext_fb_list.ext_fb);
1059 if (framestats_file) fclose(framestats_file);
1066int main(
int argc,
const char **argv_) {
1067 unsigned int loops = 1, i;
1068 char **argv, **argi, **argj;
1072 argv = argv_dup(argc - 1, argv_ + 1);
1074 fprintf(stderr,
"Error allocating argument list\n");
1075 return EXIT_FAILURE;
1077 for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step) {
1078 memset(&arg, 0,
sizeof(arg));
1081 if (arg_match(&arg, &looparg, argi)) {
1082 loops = arg_parse_uint(&arg);
1087 for (i = 0; !error && i < loops; i++) error = main_loop(argc, argv_);
Describes the decoder algorithm interface to applications.
#define AOM_PLANE_U
Definition aom_image.h:227
@ AOM_CSP_COLOCATED
Definition aom_image.h:146
#define AOM_PLANE_Y
Definition aom_image.h:226
#define AOM_PLANE_V
Definition aom_image.h:228
aom_image_t * aom_img_alloc(aom_image_t *img, aom_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align)
Open a descriptor, allocating storage for the underlying image.
@ AOM_IMG_FMT_I42016
Definition aom_image.h:56
@ AOM_IMG_FMT_I420
Definition aom_image.h:45
@ AOM_IMG_FMT_YV12
Definition aom_image.h:43
void aom_img_free(aom_image_t *img)
Close an image descriptor.
Provides definitions for using AOM or AV1 within the aom Decoder interface.
@ AOMD_GET_FRAME_CORRUPTED
Codec control function to check if the indicated frame is corrupted, int* parameter.
Definition aomdx.h:204
@ AV1D_SET_SKIP_FILM_GRAIN
Codec control function to set the skip film grain flag, int parameter.
Definition aomdx.h:390
@ AV1D_SET_IS_ANNEXB
Codec control function to indicate whether bitstream is in Annex-B format, unsigned int parameter.
Definition aomdx.h:352
@ AV1D_SET_ROW_MT
Codec control function to enable the row based multi-threading of decoding, unsigned int parameter.
Definition aomdx.h:347
@ AV1D_GET_DISPLAY_SIZE
Codec control function to get the current frame's intended display dimensions (as specified in the wr...
Definition aomdx.h:225
@ AV1D_SET_OUTPUT_ALL_LAYERS
Codec control function to indicate whether to output one frame per temporal unit (the default),...
Definition aomdx.h:374
@ AV1D_SET_OPERATING_POINT
Codec control function to indicate which operating point to use, int parameter.
Definition aomdx.h:362
@ AOMD_GET_LAST_QUANTIZER
Codec control function to get last decoded frame quantizer, int* parameter.
Definition aomdx.h:297
aom_codec_err_t aom_codec_set_frame_buffer_functions(aom_codec_ctx_t *ctx, aom_get_frame_buffer_cb_fn_t cb_get, aom_release_frame_buffer_cb_fn_t cb_release, void *cb_priv)
Pass in external frame buffers for the decoder to use.
const char * aom_codec_iface_name(aom_codec_iface_t *iface)
Return the name for a given interface.
const struct aom_codec_iface aom_codec_iface_t
Codec interface structure.
Definition aom_codec.h:271
const char * aom_codec_error(const aom_codec_ctx_t *ctx)
Retrieve error synopsis for codec context.
aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx)
Destroy a codec instance.
#define AOM_CODEC_CONTROL_TYPECHECKED(ctx, id, data)
aom_codec_control wrapper macro (adds type-checking, less flexible)
Definition aom_codec.h:542
const char * aom_codec_error_detail(const aom_codec_ctx_t *ctx)
Retrieve detailed error information for codec context.
const void * aom_codec_iter_t
Iterator.
Definition aom_codec.h:305
aom_codec_err_t aom_codec_peek_stream_info(aom_codec_iface_t *iface, const uint8_t *data, size_t data_sz, aom_codec_stream_info_t *si)
Parse stream info from a buffer.
aom_image_t * aom_codec_get_frame(aom_codec_ctx_t *ctx, aom_codec_iter_t *iter)
Decoded frames iterator.
aom_codec_err_t aom_codec_decode(aom_codec_ctx_t *ctx, const uint8_t *data, size_t data_sz, void *user_priv)
Decode data.
#define aom_codec_dec_init(ctx, iface, cfg, flags)
Convenience macro for aom_codec_dec_init_ver()
Definition aom_decoder.h:129
Codec context structure.
Definition aom_codec.h:315
const char * name
Definition aom_codec.h:316
Initialization Configurations.
Definition aom_decoder.h:91
unsigned int threads
Definition aom_decoder.h:92
External frame buffer.
Definition aom_frame_buffer.h:40
uint8_t * data
Definition aom_frame_buffer.h:41
size_t size
Definition aom_frame_buffer.h:42
void * priv
Definition aom_frame_buffer.h:43
Initialization-time Feature Enabling.
Definition aom_decoder.h:71
unsigned int h
Definition aom_decoder.h:73
unsigned int w
Definition aom_decoder.h:72
Image Descriptor.
Definition aom_image.h:198
unsigned int bit_depth
Definition aom_image.h:210
aom_chroma_sample_position_t csp
Definition aom_image.h:204
aom_img_fmt_t fmt
Definition aom_image.h:199
int stride[3]
Definition aom_image.h:232
unsigned int d_w
Definition aom_image.h:213
int monochrome
Definition aom_image.h:203
unsigned int d_h
Definition aom_image.h:214
aom_color_range_t range
Definition aom_image.h:205
unsigned char * planes[3]
Definition aom_image.h:231